package com.gxm.base.grammar_运算语法.lambda;

import org.junit.Test;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class 匿名类Demo {
    /**
     * 不写一个新的类,使用时 直接 实例化接口或抽象类 {} 内写 具体实现
     * 匿名内部类必须有父类或实现某个接口
     * 就是用一次时,用匿名内部类
     * 根据方法参数类型 自动 推断 数据类型
     * @param args
     */
    public static void main(String[] args) {
        Thread thread = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }

            }
        };
        thread.start();

        Runnable r = new Runnable() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
    }

    @Test
    public void lambdaTest1() {
        //传统写法,去重
        List<Integer> list = Arrays.asList(1, 2, 3, 3, 2, 4);
        Set<Integer> integerSet = new HashSet<>();
        for (Integer i : list) {
            integerSet.add(i);
        }
        System.out.println(integerSet.toString());
        list = Arrays.asList(1, 2, 3, 3, 2, 4);
        //lambda 写法
        integerSet = list.stream().collect(Collectors.toSet());
        System.out.println(integerSet.toString());
    }

    @Test
    public void lambdaTest2() {
        //传统匿名内部类 使用方法
        TestLambdaInterface l1 = new TestLambdaInterface() {
            @Override
            public void test() {
                System.out.println("你用匿名内部类实现的抽象方法");
            }
        };
        l1.test();
        //lambada 演示 去掉 new {}==> -> 方法名 只留实现
        TestLambdaInterface l2 = () -> {
            System.out.println("你用lambda实现的抽象方法");
        };
        l2.test();

        l2 = ()->System.out.println("省略了大括号{}的lambda实现的抽象方法");
        l2.test();

        TestLambdaInterface2 l21 = (s)->{
            System.out.println("有1个参数的抽象方法实现,参数为:"+s);
        };
        l21.test("参数");
        //抽象方法有两个参数时,()不能省略
    }
}

interface TestLambdaInterface {
    void test();
}

interface TestLambdaInterface2 {
    void test(String str);
}